train.csv et test.csv dans l'onglet datainputLancer votre notebook grâce à la commande dans votre terminal
jupyter notebook
In [7]:
# Importer les lib python
import pandas as pd
Petit rappel pour lire un fichier en local, utiliser la fonction read_csv
Si vous avez des difficultés à utiliser une fonction, vous pouvez taper le nom de la fonction + "?" :
pd.read_csv?Pour fermer la fenêtre d'aide, cliquez sur la croix en haut à gauche de la fenêtre d'aide
In [8]:
# Lire un fichier Train
train = pd.read_csv('input/train.csv')
Pour regarder un fichier, vous pouvez taper :
- le nom du DataFrame --> Afficher l'ensemble du DataFrame
- Utiliser ".head()" --> Affiche les 5 premières lignes
- Utiliser ".tail()" --> Affiche les 5 dernières lignes
In [9]:
# Regarder le début d'un DataFrame
train.head(17)
Out[9]:
Signification des colonnes :
- Survived : indique la mort ou la survie du passager pour les données d'apprentissage. C'est ce que l'on doit prédire sur fichier test. Cette valeur est booléene (0 ou 1) : 1 pour survie, 0 pour la mort
- Pclass : La classe des chambres du navire (3 niveaux), 1 étant la meilleure classe et 3 la classe "éco". C'est une variable texte qui va falloir transformer en faisant attention car il y a une notion d'ordre.
- Name : Nom de la personne
- Sex : Sexe du passager
- Age : âge du passager
- SisbSp : (Sibling and Spouse) : le nombre de membres de la famille du passager de type frère, soeur, demi-frère, demi-soeur, époux, épouse...
- Parch : (Parent and Child) : le nombre de membres de la famille du passager du type père, mère, fils, fille, beau-fils, etc...
- Ticket : Numéro du ticket
- Fare : le prix du ticket
- Cabin : numéro de cabine
- Embarked : le port d'embarquement du passager : C -> Cherbourg; Q -> Queenstown; S -> Southampton
In [10]:
train.count()
Out[10]:
count() permet de voir qu'il y a des données qui sont manquantes / absentes
On va crée un function python afin de faciler le reproduction par la suite
Target est donc notre cible (ce que l'on essaye de prédire')
In [76]:
def parse_model(X):
"""
Parse mes données pour nourrir un algo.
- Return :
- X : features pour prédire le résutat
- target : si la personne à survécu ou est morte
"""
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch']]
return X, target
In [77]:
X, y = parse_model(train.copy())
X sont nos données afin de déviner si le passager est mort ou non
In [13]:
X.head()
Out[13]:
y est la valeur booléen de survit ou non du Titanic
In [14]:
y.head()
Out[14]:
In [15]:
X.shape
Out[15]:
In [16]:
y.shape
Out[16]:
In [17]:
# Permet de valider notre modèle
from sklearn.cross_validation import cross_val_score, train_test_split
# Modèle linéaire
from sklearn.linear_model import LogisticRegression
In [18]:
# Etape 1
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=2017)
In [19]:
# Ce sont des Features :
print"X_train : " + str(X_train.shape)
print"X_test : " + str(X_test.shape)
# Ce sont des Targets :
print"y_train : " + str(y_train.shape)
print"y_test : " + str(y_test.shape)
In [20]:
X_train.tail()
Out[20]:
In [21]:
y_train.tail()
Out[21]:
In [22]:
ma_regression = LogisticRegression() # On initialise notre algo
ma_regression.fit(X_train, y_train)
Out[22]:
In [23]:
#ma_regression?
In [24]:
ma_prediction = ma_regression.predict(X_test)
# ma_prediction est un array (= list)
ma_prediction[5:10] # On affiche les 5 premiers résultats
Out[24]:
In [25]:
y_test[5:10]
Out[25]:
In [26]:
# Mon score de précision sur mes données d'apprentissage
ma_regression.score(X_train, y_train)
Out[26]:
In [27]:
# Etape 2
# Function de score
from sklearn.metrics import accuracy_score
accuracy_score(y_test, ma_prediction)
Out[27]:
On peux voir en changeant le chiffre du paramêtre random_state de train_test_split (étape 1) que le résultat du score sur les données d'apprentissage et sur les données test change
D'ailleurs l'étape 2 est égal :
In [28]:
accuracy_score(y_train, ma_regression.predict(X_train))
Out[28]:
In [29]:
from sklearn.cross_validation import cross_val_score
def cross_validation_score(algo, X, y):
"""
Utilise une cross validation sur un algo et return tout ses scores
"""
score_cv = cross_val_score(algo, X, y, cv=5)
return score_cv
In [30]:
mon_score = cross_validation_score(ma_regression, X, y)
In [31]:
print "Voila le résultat de la CV " + str(mon_score)
In [32]:
print "Voila la moyenne de la CV " + str(mon_score.mean())
Charger le fichier test :
In [33]:
test = pd.read_csv("input/test.csv")
test.head()
Out[33]:
In [34]:
X_test.head()
Out[34]:
In [35]:
test[['Fare', 'SibSp', 'Parch']].head()
Out[35]:
In [78]:
# Etape 3
# On fit notre algo
ma_regression.fit(X, y)
use_features = ['Fare', 'SibSp', 'Parch']
prediction = ma_regression.predict(test[use_features])
# Error
Il semble que nos données de test soient NaN (absentes)
In [37]:
pd.isnull(test[use_features]).sum()
Out[37]:
In [38]:
test[pd.isnull(test.Fare)][use_features]
Out[38]:
On va donc remplacer cette valeur manquante :
- Soit on choisit une valeur subjective
- On prend la valeur la plus adéquate sur notre jeux de données **train** (comme la médiane)
In [39]:
# Lib de calcul
import numpy as np
mediane_fare = np.median(train['Fare'])
print "La medianne de Fare dans notre jeu de données train est : " + str(mediane_fare)
Il faut donc remplacer la / les valeurs manquantes de Fare dans notre jeu de données test par la médiane calculé
In [40]:
test['Fare'] = test['Fare'].fillna(mediane_fare)
test[pd.isnull(test.Fare)][use_features] # Plus de Fare NaN
Out[40]:
On reprendre notre étape 3 :
In [41]:
# Etape 3 bis
# On fit notre algo
ma_regression.fit(X, y)
use_features = ['Fare', 'SibSp', 'Parch']
test['Fare'] = test['Fare'].fillna(mediane_fare) # notre fix /!\
prediction = ma_regression.predict(test[use_features])
In [42]:
print prediction
In [43]:
test.shape
Out[43]:
In [44]:
len(prediction)
Out[44]:
In [45]:
# On ajoute notre prédiction sur notre jeux de données test
test['Survived'] = prediction
fichier_prediction = test[['PassengerId', 'Survived']]
fichier_prediction.head()
Out[45]:
In [46]:
train.Survived.value_counts(normalize=True)
Out[46]:
In [47]:
fichier_prediction.Survived.value_counts(normalize=True)
Out[47]:
Créer un dossier "output" au même niveau que le dossier "input"
In [48]:
# Ecrire un fichier à partir d'un DataFrame
fichier_prediction.to_csv('output/premier_test.csv', index=False)
Aller sur Kaggle et faite une submission afin de voir votre score :)
In [49]:
# 0.6555 est assez proche de notre CV
Comment faire mieux que notre premier modèle. Il faut garder en mémoire que l'on à utiliser seulement 3 features...
In [50]:
# Pour afficher des images (pas besoin de taper cet import)
from IPython.display import Image
Image(url="http://i.giphy.com/9ABgKHIu3acWA.gif")
Out[50]:
In [51]:
import seaborn as sns
import matplotlib.pyplot as plt
# Pour que les graphique s'affichent dans le notebook
%matplotlib inline
In [52]:
train.head()
Out[52]:
In [53]:
sns.countplot(train.Pclass, hue=train.Survived)
Out[53]:
In [54]:
pd.get_dummies(train.Pclass, prefix="split_Pclass").head()
Out[54]:
In [55]:
def parse_model_1(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
X = X.drop('Pclass', axis=1)
return X, target
In [56]:
X, y = parse_model_1(train)
In [57]:
X.head()
Out[57]:
In [58]:
y.head()
Out[58]:
In [59]:
mon_score_2 = cross_validation_score(ma_regression, X, y)
In [60]:
mon_score_2
Out[60]:
In [61]:
print "Voila la moyenne de la CV " + str(mon_score_2.mean())
In [62]:
mon_score_2.mean()
Out[62]:
In [63]:
# 1er score = 0.674
In [64]:
# On recherche notre jeu de données test
mon_test = pd.read_csv("input/test.csv")
In [65]:
# Etape 3 bis
ma_regression.fit(X, y)
#use_features = ['Fare', 'SibSp', 'Parch', 'Pclass']
mon_test = mon_test[['Fare', 'SibSp', 'Parch', 'Pclass']]
mes_dummy_test = pd.get_dummies(mon_test.Pclass, prefix="split_Pclass")
mon_test = mon_test.join(mes_dummy_test)
mon_test = mon_test.drop('Pclass', axis=1)
mon_test['Fare'] = mon_test['Fare'].fillna(mediane_fare)
In [66]:
mon_test.head()
Out[66]:
In [67]:
ma_regression.fit(X,y)
Out[67]:
In [68]:
prediction = ma_regression.predict(mon_test)
In [69]:
prediction
Out[69]:
In [70]:
# On ajoute notre prédiction sur notre jeux de données test
test['Survived'] = prediction
fichier_prediction = test[['PassengerId', 'Survived']]
fichier_prediction.head()
Out[70]:
In [71]:
ma_regression.coef_
Out[71]:
In [80]:
mon_resultat = pd.DataFrame({'coef' : ma_regression.coef_[0],
'features' : X.columns})
#mon_resultat['coef'] = ma_regression.coef_[0]
#mon_resultat['features'] = ['Fare', 'SibSp', 'Parch', 'Pclass']
In [73]:
mon_resultat
Out[73]:
In [74]:
plt.figure(figsize=(10,8))
sns.barplot(x='features', y='coef', data=mon_resultat)
Out[74]:
In [81]:
# 1 er modèle
# Reload le modèle 1
plt.figure(figsize=(10,8))
sns.barplot(x='features', y='coef', data=mon_resultat)
Out[81]:
Un poid positif augmente la probalité de survie. Un poid négatif diminue la probabilité de survie.
In [82]:
train.head()
Out[82]:
In [83]:
def parse_model_2(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
X = X.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex = pd.get_dummies(X.Sex, prefix="split_Sex")
X = X.join(mes_dummy_Sex)
X = X.drop('Sex', axis=1)
return X, target
In [84]:
X, y = parse_model_2(train.copy())
In [85]:
X.head()
Out[85]:
In [86]:
mon_score_3 = cross_validation_score(ma_regression, X, y)
In [87]:
mon_score_3
Out[87]:
In [88]:
mon_score_3.mean()
Out[88]:
In [89]:
ma_regression.fit(X, y)
Out[89]:
In [90]:
# On recherche notre jeu de données test
mon_test = pd.read_csv("input/test.csv")
#use_features = [['Fare', 'SibSp', 'Parch', 'Pclass']]
mon_test = mon_test[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex']]
# Pclass
mes_dummy_Pclass_test = pd.get_dummies(mon_test.Pclass, prefix="split_Pclass")
mon_test = mon_test.join(mes_dummy_Pclass_test)
mon_test = mon_test.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex_test = pd.get_dummies(mon_test.Sex, prefix="split_Sex")
mon_test = mon_test.join(mes_dummy_Sex_test)
mon_test = mon_test.drop('Sex', axis=1)
# Autres
mon_test['Fare'] = mon_test['Fare'].fillna(mediane_fare)
In [91]:
mon_test.head()
Out[91]:
In [92]:
prediction = ma_regression.predict(mon_test)
In [93]:
prediction
Out[93]:
In [94]:
# On ajoute notre prédiction sur notre jeux de données test
test['Survived'] = prediction
fichier_prediction = test[['PassengerId', 'Survived']]
fichier_prediction.head()
Out[94]:
In [95]:
# Ecrire un fichier à partir d'un DataFrame
fichier_prediction.to_csv('output/test_3.csv', index=False)
In [96]:
train.tail()
Out[96]:
In [97]:
def parse_model_3(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex', 'Age']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
X = X.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex = pd.get_dummies(X.Sex, prefix="split_Sex")
X = X.join(mes_dummy_Sex)
X = X.drop('Sex', axis=1)
# Enfant oui ou non ?
X['enfant'] = 0
X.loc[X.Age <= 10, 'enfant'] = 1
X = X.drop('Age', axis=1)
return X, target
In [98]:
X, y = parse_model_3(train.copy())
In [99]:
X.head()
Out[99]:
In [100]:
X.enfant.value_counts(normalize=True)
Out[100]:
In [101]:
mon_score_4 = cross_validation_score(ma_regression, X, y)
In [102]:
mon_score_4
Out[102]:
In [103]:
mon_score_4.mean()
Out[103]:
In [104]:
# On recherche notre jeu de données test
mon_test = pd.read_csv("input/test.csv")
#use_features = [['Fare', 'SibSp', 'Parch', 'Pclass']]
mon_test = mon_test[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex','Age']]
# Pclass
mes_dummy_Pclass_test = pd.get_dummies(mon_test.Pclass, prefix="split_Pclass")
mon_test = mon_test.join(mes_dummy_Pclass_test)
mon_test = mon_test.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex_test = pd.get_dummies(mon_test.Sex, prefix="split_Sex")
mon_test = mon_test.join(mes_dummy_Sex_test)
mon_test = mon_test.drop('Sex', axis=1)
# Enfant oui ou non ?
mon_test['enfant'] = 0
mon_test.loc[mon_test.Age <= 10, 'enfant'] = 1
mon_test = mon_test.drop('Age', axis=1)
# Autres
mon_test['Fare'] = mon_test['Fare'].fillna(mediane_fare)
In [105]:
mon_test.head()
Out[105]:
In [106]:
ma_regression.fit(X, y)
Out[106]:
In [107]:
prediction = ma_regression.predict(mon_test)
In [108]:
prediction
Out[108]:
In [109]:
# On ajoute notre prédiction sur notre jeux de données test
test['Survived'] = prediction
fichier_prediction = test[['PassengerId', 'Survived']]
fichier_prediction.head()
Out[109]:
In [110]:
# Ecrire un fichier à partir d'un DataFrame
fichier_prediction.to_csv('output/test_4.csv', index=False)
In [111]:
mon_resultat = pd.DataFrame({'coef' : ma_regression.coef_[0],
'features' : X.columns})
#mon_resultat['coef'] = ma_regression.coef_[0]
#mon_resultat['features'] = ['Fare', 'SibSp', 'Parch', 'Pclass']
In [112]:
plt.figure(figsize=(10,8))
sns.barplot(x='features', y='coef', data=mon_resultat)
Out[112]:
In [179]:
def parse_model_4(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex', 'Age']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
X = X.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex = pd.get_dummies(X.Sex, prefix="split_Sex")
X = X.join(mes_dummy_Sex)
X = X.drop('Sex', axis=1)
# Amélioration de la données Age (processing à faire avant la variable "Enfant" car impacté)
## Nécessaire pour réaliser une série qui ressemble à la série de point d'origine :
mean_age = X["Age"].mean()
std_age = X["Age"].std()
nbr_age_nan = X["Age"].isnull().sum()
new_age = np.random.randint(mean_age - std_age, mean_age + std_age, size = nbr_age_nan)
X.loc[pd.isnull(X['Age']), 'Age'] = new_age # Lorsque "Age" est NaN -> On ajoute un valeur simuler
# Enfant oui ou non ?
X['enfant'] = 0
X.loc[X.Age <= 10, 'enfant'] = 1
#X = X.drop('Age', axis=1) # Attention cette fois on laisse Age en features :
return X, target
In [180]:
X, y = parse_model_4(train.copy())
In [181]:
X.head()
Out[181]:
In [182]:
X.enfant.value_counts(normalize=True)
Out[182]:
In [183]:
mon_score_5 = cross_validation_score(ma_regression, X, y)
mon_score_5
Out[183]:
In [184]:
mon_score_5.mean()
# Ancien meilleur = 0.79797
Out[184]:
In [151]:
# On recherche notre jeu de données test
mon_test = pd.read_csv("input/test.csv")
#use_features = [['Fare', 'SibSp', 'Parch', 'Pclass']]
mon_test = mon_test[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex','Age']]
# Pclass
mes_dummy_Pclass_test = pd.get_dummies(mon_test.Pclass, prefix="split_Pclass")
mon_test = mon_test.join(mes_dummy_Pclass_test)
mon_test = mon_test.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex_test = pd.get_dummies(mon_test.Sex, prefix="split_Sex")
mon_test = mon_test.join(mes_dummy_Sex_test)
mon_test = mon_test.drop('Sex', axis=1)
# Amélioration Age : (On se base uniquement sur les données de Train pour calculer la moyenne / std ..)
mean_age = X["Age"].mean()
std_age = X["Age"].std()
nbr_age_nan = mon_test["Age"].isnull().sum() # On prend le nombre de valeur NaN du test
new_age = np.random.randint(mean_age - std_age, mean_age + std_age, size = nbr_age_nan)
mon_test.loc[pd.isnull(mon_test['Age']), 'Age'] = new_age # Lorsque "Age" est NaN -> On ajoute un valeur simuler
# Enfant oui ou non ?
mon_test['enfant'] = 0
mon_test.loc[mon_test.Age <= 10, 'enfant'] = 1
#mon_test = mon_test.drop('Age', axis=1) # On ne supprime plus Age en variable.
# Autres
mon_test['Fare'] = mon_test['Fare'].fillna(mediane_fare)
In [152]:
mon_test.head()
Out[152]:
In [185]:
ma_regression.fit(X, y)
Out[185]:
In [186]:
prediction = ma_regression.predict(mon_test)
In [187]:
# On ajoute notre prédiction sur notre jeux de données test
test['Survived'] = prediction
fichier_prediction = test[['PassengerId', 'Survived']]
fichier_prediction.head()
Out[187]:
In [188]:
# Ecrire un fichier à partir d'un DataFrame
fichier_prediction.to_csv('output/test_5.csv', index=False)
In [192]:
mon_resultat = pd.DataFrame({'coef' : ma_regression.coef_[0],
'features' : X.columns})
In [193]:
plt.figure(figsize=(10,8))
g = sns.barplot(x='features', y='coef', data=mon_resultat)
g.set_xticklabels(mon_resultat.features, rotation=20)
Out[193]:
In [445]:
moi = pd.DataFrame()
moi['Fare']=30,
moi['SibSp']=1,
moi['Parch']=2,
moi['split_Pclass_1']=1,
moi['split_Pclass_2']=0,
moi['split_Pclass_3']=0,
moi['split_Sex_female']=0,
moi['split_Sex_male']=1,
moi['age']=31,
moi['enfant']=0
In [446]:
moi
Out[446]:
In [447]:
moi_prediction = ma_regression.predict(moi)
In [449]:
# 1 = survie / 0 = mort
print 'je suis ....' + str(moi_prediction)
In [450]:
# Probabilité de survie
ma_regression.predict_proba(moi)[0][1]
Out[450]:
In [284]:
def parse_model_6(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex', 'Age']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
X = X.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex = pd.get_dummies(X.Sex, prefix="split_Sex")
X = X.join(mes_dummy_Sex)
X = X.drop('Sex', axis=1)
# Amélioration de la données Age (processing à faire avant la variable "Enfant" car impacté)
## Nécessaire pour réaliser une série qui ressemble à la série de point d'origine :
mean_age = X["Age"].mean()
std_age = X["Age"].std()
nbr_age_nan = X["Age"].isnull().sum()
new_age = np.random.randint(mean_age - std_age, mean_age + std_age, size = nbr_age_nan)
X.loc[pd.isnull(X['Age']), 'Age'] = new_age # Lorsque "Age" est NaN -> On ajoute un valeur simuler
# Enfant oui ou non ?
X['enfant'] = 0
X.loc[X.Age <= 10, 'enfant'] = 1
#X = X.drop('Age', axis=1) # Attention cette fois on laisse Age en features :
# Size familly :
X['family_size'] = X['SibSp'] + X['Parch'] # Adding Here
return X, target
In [285]:
X, y = parse_model_6(train.copy())
In [286]:
mon_score_6 = cross_validation_score(ma_regression, X, y)
mon_score_6
Out[286]:
In [287]:
mon_score_6.mean()
# Moins bien
Out[287]:
In [288]:
def parse_model_7(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex', 'Age']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
X = X.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex = pd.get_dummies(X.Sex, prefix="split_Sex")
X = X.join(mes_dummy_Sex)
X = X.drop('Sex', axis=1)
# Amélioration de la données Age (processing à faire avant la variable "Enfant" car impacté)
## Nécessaire pour réaliser une série qui ressemble à la série de point d'origine :
mean_age = X["Age"].mean()
std_age = X["Age"].std()
nbr_age_nan = X["Age"].isnull().sum()
new_age = np.random.randint(mean_age - std_age, mean_age + std_age, size = nbr_age_nan)
X.loc[pd.isnull(X['Age']), 'Age'] = new_age # Lorsque "Age" est NaN -> On ajoute un valeur simuler
# Enfant oui ou non ?
X['enfant'] = 0
X.loc[X.Age <= 10, 'enfant'] = 1
#X = X.drop('Age', axis=1) # Attention cette fois on laisse Age en features :
# Size familly :
X['family_size'] = X['SibSp'] + X['Parch']
X['family_size_age'] = X['family_size'] * X['Age']
return X, target
In [289]:
X, y = parse_model_7(train.copy())
In [290]:
mon_score_7 = cross_validation_score(ma_regression, X, y)
mon_score_7
Out[290]:
In [291]:
mon_score_7.mean()
Out[291]:
In [295]:
def parse_model_8(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex', 'Age']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
#X = X.drop('Pclass', axis=1)
# Amélioration de la données Age (processing à faire avant la variable "Enfant" car impacté)
## Nécessaire pour réaliser une série qui ressemble à la série de point d'origine :
#mean_age = X["Age"].mean()
#std_age = X["Age"].std()
#nbr_age_nan = X["Age"].isnull().sum()
#new_age = np.random.randint(mean_age - std_age, mean_age + std_age, size = nbr_age_nan)
#X.loc[pd.isnull(X['Age']), 'Age'] = new_age # Lorsque "Age" est NaN -> On ajoute un valeur simuler
X.loc[pd.isnull(X['Age']), 'Age'] = X.Age.median()
# Enfant oui ou non ?
X['enfant'] = 0
X.loc[X.Age <= 10, 'enfant'] = 1
X.loc[X.enfant == 1,'Sex'] = 'Child'
X = X.drop('enfant', axis=1) # Attention cette fois on laisse Age en features :
# Update Enfent sex :
# Sex
mes_dummy_Sex = pd.get_dummies(X.Sex, prefix="split_Sex")
X = X.join(mes_dummy_Sex)
X = X.drop('Sex', axis=1)
# Size familly :
X['family_size'] = X['SibSp'] + X['Parch']
# Strange Features
X['age*Pclass'] = X['Pclass'] * X['Age']
X = X.drop('Pclass', axis=1)
return X, target
In [296]:
X, y = parse_model_8(train.copy())
In [297]:
mon_score_8 = cross_validation_score(ma_regression, X, y)
mon_score_8.mean() # Meillieur score /!\
Out[297]:
In [298]:
ma_regression.fit(X, y)
Out[298]:
In [299]:
mon_resultat = pd.DataFrame({'coef' : ma_regression.coef_[0],
'features' : X.columns})
In [300]:
plt.figure(figsize=(10,8))
g = sns.barplot(x='features', y='coef', data=mon_resultat)
g.set_xticklabels(mon_resultat.features, rotation=20)
Out[300]:
In [306]:
train.head()
Out[306]:
Nous n'avons pas encore analyse l'ensemble des colonnes disponibles...
La colonne Name peux offrir de précieuses informations, mais celle-ci est du texte
In [311]:
# Le titre est derrière la virgule
# Ensemble des titres que l'on récupère de cette façon
train['Name'].apply(lambda x: x.split(',')[1].split('.')[0].strip()).value_counts()
Out[311]:
In [313]:
train['Title'] = train['Name'].apply(lambda x: x.split(',')[1].split('.')[0].strip())
In [317]:
train[train['Title'] == 'Rev']
Out[317]:
Maintenant que nous avons l'ensemble des titres, nous allons les regrouper
In [319]:
title_dict = {
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Dr": "Officer",
"Rev": "Officer",
"Jonkheer": "Royalty",
"Don": "Royalty",
"Sir" : "Royalty",
"the Countess":"Royalty",
"Dona": "Royalty",
"Lady" : "Royalty",
"Mme": "Mrs",
"Mlle": "Miss",
"Ms": "Mrs",
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "Master"}
In [320]:
train['Title_grp'] = train['Title'].map(title_dict)
In [322]:
train.tail()
Out[322]:
In [328]:
def parse_model_9(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex', 'Age', 'Name']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
#X = X.drop('Pclass', axis=1)
# Amélioration de la données Age (processing à faire avant la variable "Enfant" car impacté)
## Nécessaire pour réaliser une série qui ressemble à la série de point d'origine :
#mean_age = X["Age"].mean()
#std_age = X["Age"].std()
#nbr_age_nan = X["Age"].isnull().sum()
#new_age = np.random.randint(mean_age - std_age, mean_age + std_age, size = nbr_age_nan)
#X.loc[pd.isnull(X['Age']), 'Age'] = new_age # Lorsque "Age" est NaN -> On ajoute un valeur simuler
X.loc[pd.isnull(X['Age']), 'Age'] = X.Age.median()
# Enfant oui ou non ?
X['enfant'] = 0
X.loc[X.Age <= 10, 'enfant'] = 1
X.loc[X.enfant == 1,'Sex'] = 'Child'
X = X.drop('enfant', axis=1) # Attention cette fois on laisse Age en features :
# Update Enfent sex :
# Sex
mes_dummy_Sex = pd.get_dummies(X.Sex, prefix="split_Sex")
X = X.join(mes_dummy_Sex)
X = X.drop('Sex', axis=1)
# Size familly :
X['family_size'] = X['SibSp'] + X['Parch']
# Strange Features
X['age*Pclass'] = X['Pclass'] * X['Age']
X = X.drop('Pclass', axis=1)
# Name
X['Title'] = X['Name'].apply(lambda x: x.split(',')[1].split('.')[0].strip())
X['Title_grp'] = X['Title'].map(title_dict)
X = X.drop(['Title', 'Name'], axis=1)
## Dummy de Title grp
mes_Title_grp = pd.get_dummies(X.Title_grp, prefix="is")
X = X.join(mes_Title_grp)
X = X.drop('Title_grp', axis=1)
return X, target
In [329]:
X, y = parse_model_9(train.copy())
In [330]:
X.head()
Out[330]:
In [332]:
mon_score_9 = cross_validation_score(ma_regression, X, y)
mon_score_9.mean() # moins bon... :'(
Out[332]:
In [333]:
ma_regression.fit(X, y)
Out[333]:
In [334]:
mon_resultat = pd.DataFrame({'coef' : ma_regression.coef_[0],
'features' : X.columns})
In [336]:
plt.figure(figsize=(15,6))
g = sns.barplot(x='features', y='coef', data=mon_resultat)
g.set_xticklabels(mon_resultat.features, rotation=20)
Out[336]:
In [337]:
from sklearn import metrics
In [338]:
train_prediction = ma_regression.predict(X)
In [340]:
cm = metrics.confusion_matrix(y_true=y, # True labels
y_pred=train_prediction) # Predicted labels
cm
Out[340]:
In [341]:
cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
cm_normalized
Out[341]:
In [342]:
label_unique = y.unique()
# Graph Confusion Matrix
tick_marks = np.arange(len(label_unique))
plt.figure(figsize=(8,6))
sns.heatmap(cm_normalized, cmap='Greens',annot=True,linewidths=.5)
plt.title('confusion matrix')
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.xticks(tick_marks + 0.5, list(label_unique))
plt.yticks(tick_marks + 0.5, list(reversed(list(label_unique))), rotation=0)
Out[342]:
On prédit correctement :
Un algorithme ne sera jamais parfait ! On peux toujours le complexifier, il restera toujours des erreurs. Cependant il est important de bien comprendre ces erreurs. La bonne compréhension de celles-ci est une phase crucial dans l'analyse de données et dans la méthodologie d'amélioration.
Dans le cadre d'un besoin d'entreprise, un BI pro-actif offre une vision sur un possible problème, laissant un certain temps de réaction pour le résoudre. De plus il offre aussi des indicateurs forts utiles (coeficients) pour l'aspect stratégique / métier.
In [ ]: